var runtime.gcController

155 uses

	runtime (current package)
		arena.go#L885: 	gcController.heapInUse.add(-int64(s.npages * pageSize))
		arena.go#L891: 	gcController.totalFree.Add(int64(s.elemsize))
		arena.go#L905: 	gcController.update(-int64(s.elemsize), 0)
		arena.go#L1049: 	sysMap(unsafe.Pointer(base), userArenaChunkBytes, &gcController.heapReleased, "user arena chunk")
		arena.go#L1079: 	gcController.heapInUse.add(int64(userArenaChunkBytes))
		arena.go#L1080: 	gcController.heapReleased.add(-int64(userArenaChunkBytes))
		arena.go#L1092: 	gcController.totalAlloc.Add(int64(s.elemsize))
		arena.go#L1095: 	gcController.update(int64(s.elemsize), 0)
		malloc.go#L723: 	gcController.memoryLimit.Store(math.MaxInt64)
		malloc.go#L752: 		v = h.arena.alloc(n, heapArenaBytes, &gcController.heapReleased, "heap")
		mcache.go#L198: 		gcController.totalAlloc.Add(bytesAllocated)
		mcache.go#L235: 	gcController.update(int64(s.npages*pageSize)-int64(usedBytes), int64(c.scanAlloc))
		mcache.go#L269: 	gcController.totalAlloc.Add(int64(npages * pageSize))
		mcache.go#L272: 	gcController.update(int64(s.npages*pageSize), 0)
		mcache.go#L310: 			gcController.totalAlloc.Add(slotsUsed * int64(s.elemsize))
		mcache.go#L344: 	gcController.update(dHeapLive, scanAlloc)
		mem.go#L51: 	gcController.mappedReady.Add(int64(n))
		mem.go#L69: 	gcController.mappedReady.Add(-int64(n))
		mem.go#L90: 	gcController.mappedReady.Add(int64(prepared))
		mem.go#L143: 	gcController.mappedReady.Add(-int64(n))
		mem.go#L157: 	gcController.mappedReady.Add(-int64(n))
		metrics.go#L312: 				out.scalar = uint64(gcController.memoryLimit.Load())
		metrics.go#L318: 				out.scalar = uint64(gcController.gcPercent.Load())
		metrics.go#L325: 				out.scalar = gcController.heapMarked
		metrics.go#L726: 	a.heapGoal = gcController.heapGoal()
		metrics.go#L767: 	a.heapScan = gcController.heapScan.Load()
		metrics.go#L768: 	a.stackScan = gcController.lastStackScan.Load()
		metrics.go#L769: 	a.globalsScan = gcController.globalsScan.Load()
		mgc.go#L189: 	gcController.init(readGOGC(), readGOMEMLIMIT())
		mgc.go#L314: 	delta := now - gcController.markStartTime
		mgc.go#L322: 	return float64(selfTime)/float64(delta) > 1.2*gcController.fractionalUtilizationGoal
		mgc.go#L712: 		trigger, _ := gcController.trigger()
		mgc.go#L713: 		return gcController.heapLive.Load() >= trigger
		mgc.go#L715: 		if gcController.gcPercent.Load() < 0 {
		mgc.go#L827: 	work.heap0 = gcController.heapLive.Load()
		mgc.go#L881: 	gcController.startCycle(now, int(gomaxprocs), trigger)
		mgc.go#L1170: 	gcController.endCycle(now, int(gomaxprocs), work.userForced)
		mgc.go#L1348: 	work.heap1 = gcController.heapLive.Load()
		mgc.go#L1408: 	memstats.lastHeapInUse = gcController.heapInUse.load()
		mgc.go#L1595: 			gcController.assistTime.Load(),
		mgc.go#L1596: 			gcController.dedicatedMarkTime.Load() + gcController.fractionalMarkTime.Load(),
		mgc.go#L1597: 			gcController.idleMarkTime.Load(),
		mgc.go#L1610: 			gcController.lastHeapGoal>>20, " MB goal, ",
		mgc.go#L1611: 			gcController.lastStackScan.Load()>>20, " MB stacks, ",
		mgc.go#L1612: 			gcController.globalsScan.Load()>>20, " MB globals, ",
		mgc.go#L1648: 	if gcController.heapGoal() > minHeapForMetadataHugePages {
		mgc.go#L1889: 		gcController.markWorkerStop(pp.gcMarkWorkerMode, duration)
		mgc.go#L2038: 	gcController.resetLive(work.bytesMarked)
		mgc.go#L2132: 	work.initialHeapLive = gcController.heapLive.Load()
		mgcmark.go#L227: 		workCounter = &gcController.globalsScanWork
		mgcmark.go#L233: 		workCounter = &gcController.globalsScanWork
		mgcmark.go#L263: 		workCounter = &gcController.stackScanWork
		mgcmark.go#L563: 	assistWorkPerByte := gcController.assistWorkPerByte.Load()
		mgcmark.go#L564: 	assistBytesPerWork := gcController.assistBytesPerWork.Load()
		mgcmark.go#L578: 	bgScanCredit := gcController.bgScanCredit.Load()
		mgcmark.go#L588: 		gcController.bgScanCredit.Add(-stolen)
		mgcmark.go#L755: 	assistBytesPerWork := gcController.assistBytesPerWork.Load()
		mgcmark.go#L775: 		gcController.assistTime.Add(pp.gcAssistTime)
		mgcmark.go#L813: 	if gcController.bgScanCredit.Load() > 0 {
		mgcmark.go#L842: 		gcController.bgScanCredit.Add(scanWork)
		mgcmark.go#L846: 	assistBytesPerWork := gcController.assistBytesPerWork.Load()
		mgcmark.go#L880: 		assistWorkPerByte := gcController.assistWorkPerByte.Load()
		mgcmark.go#L882: 		gcController.bgScanCredit.Add(scanWork)
		mgcmark.go#L1284: 					gcController.enlistWorker()
		mgcmark.go#L1343: 				gcController.enlistWorker()
		mgcmark.go#L1351: 			gcController.heapScanWork.Add(gcw.heapScanWork)
		mgcmark.go#L1371: 		gcController.heapScanWork.Add(gcw.heapScanWork)
		mgcmark.go#L1449: 			gcController.heapScanWork.Add(gcw.heapScanWork)
		mgcmark.go#L1458: 				gcController.enlistWorker()
		mgcpacer.go#L90: var gcController gcControllerState
		mgcpacer.go#L462: 			" (scan ", gcController.heapScan.Load()>>20, " MB in ",
		mgcpacer.go#L603: 	gcController.lastHeapGoal = c.heapGoal()
		mgcpacer.go#L957: 		live := gcController.heapLive.Add(dHeapLive)
		mgcpacer.go#L968: 			gcController.heapScan.Add(dHeapScan)
		mgcpacer.go#L1356: 		out = gcController.setGCPercent(in)
		mgcpacer.go#L1403: 		out = gcController.setMemoryLimit(in)
		mgcpacer.go#L1521: 	gcController.commit(isSweepDone())
		mgcpacer.go#L1525: 		gcController.revise()
		mgcpacer.go#L1536: 	trigger, heapGoal := gcController.trigger()
		mgcpacer.go#L1538: 	gcPaceScavenger(gcController.memoryLimit.Load(), heapGoal, gcController.lastHeapGoal)
		mgcscavenge.go#L151: 	return gcController.heapInUse.load() + gcController.heapFree.load()
		mgcscavenge.go#L179: 	mappedReady := gcController.mappedReady.Load()
		mgcscavenge.go#L408: 				gcController.mappedReady.Load() <= scavenge.memoryLimitGoal.Load()
		mgcscavenge.go#L706: 		gcController.heapReleased.load()>>10, " KiB now, ",
		mgcscavenge.go#L707: 		(gcController.heapInUse.load()*100)/heapRetained(), "% util",
		mgcscavenge.go#L783: 				gcController.heapReleased.add(nbytes)
		mgcscavenge.go#L784: 				gcController.heapFree.add(-nbytes)
		mgcsweep.go#L177: 				live := gcController.heapLive.Load()
		mgcsweep.go#L778: 			gcController.totalFree.Add(int64(nfreed) * int64(s.elemsize))
		mgcsweep.go#L814: 			gcController.totalFree.Add(int64(size))
		mgcsweep.go#L928: 	live := gcController.heapLive.Load()
		mgcsweep.go#L994: 		heapLiveBasis := gcController.heapLive.Load()
		mgcwork.go#L193: 			gcController.enlistWorker()
		mgcwork.go#L246: 			gcController.enlistWorker()
		mgcwork.go#L347: 		gcController.heapScanWork.Add(w.heapScanWork)
		mgcwork.go#L375: 			gcController.enlistWorker()
		mheap.go#L1330: 	if limit := gcController.memoryLimit.Load(); !gcCPULimiter.limiting() {
		mheap.go#L1333: 		inuse := gcController.mappedReady.Load()
		mheap.go#L1405: 		gcController.heapReleased.add(-int64(scav))
		mheap.go#L1408: 	gcController.heapFree.add(-int64(nbytes - scav))
		mheap.go#L1410: 		gcController.heapInUse.add(int64(nbytes))
		mheap.go#L1576: 			inUse := gcController.heapFree.load() + gcController.heapReleased.load() + gcController.heapInUse.load()
		mheap.go#L1593: 				sysMap(unsafe.Pointer(h.curArena.base), size, &gcController.heapReleased, "heap")
		mheap.go#L1634: 	sysMap(unsafe.Pointer(v), nBase-v, &gcController.heapReleased, "heap")
		mheap.go#L1764: 	gcController.heapFree.add(int64(nbytes))
		mheap.go#L1766: 		gcController.heapInUse.add(-int64(nbytes))
		mstats.go#L438: 	totalMapped := gcController.heapInUse.load() + gcController.heapFree.load() + gcController.heapReleased.load() +
		mstats.go#L443: 	heapGoal := gcController.heapGoal()
		mstats.go#L465: 		if gcController.heapInUse.load() != uint64(consStats.inHeap) {
		mstats.go#L466: 			print("runtime: heapInUse=", gcController.heapInUse.load(), "\n")
		mstats.go#L470: 		if gcController.heapReleased.load() != uint64(consStats.released) {
		mstats.go#L471: 			print("runtime: heapReleased=", gcController.heapReleased.load(), "\n")
		mstats.go#L475: 		heapRetained := gcController.heapInUse.load() + gcController.heapFree.load()
		mstats.go#L482: 		if gcController.totalAlloc.Load() != totalAlloc {
		mstats.go#L483: 			print("runtime: totalAlloc=", gcController.totalAlloc.Load(), "\n")
		mstats.go#L487: 		if gcController.totalFree.Load() != totalFree {
		mstats.go#L488: 			print("runtime: totalFree=", gcController.totalFree.Load(), "\n")
		mstats.go#L495: 		if gcController.mappedReady.Load() != totalMapped-uint64(consStats.released) {
		mstats.go#L496: 			print("runtime: mappedReady=", gcController.mappedReady.Load(), "\n")
		mstats.go#L514: 	stats.HeapSys = gcController.heapInUse.load() + gcController.heapFree.load() + gcController.heapReleased.load()
		mstats.go#L531: 	stats.HeapIdle = gcController.heapFree.load() + gcController.heapReleased.load()
		mstats.go#L532: 	stats.HeapInuse = gcController.heapInUse.load()
		mstats.go#L533: 	stats.HeapReleased = gcController.heapReleased.load()
		mstats.go#L949: 		markAssistCpu = gcController.assistTime.Load()
		mstats.go#L950: 		markDedicatedCpu = gcController.dedicatedMarkTime.Load()
		mstats.go#L951: 		markFractionalCpu = gcController.fractionalMarkTime.Load()
		mstats.go#L952: 		markIdleCpu = gcController.idleMarkTime.Load()
		proc.go#L3433: 		gp, tnow := gcController.findRunnableGCWorker(pp, now)
		proc.go#L3544: 	if gcBlackenEnabled != 0 && gcShouldScheduleWorker(pp) && gcController.addIdleMarkWorker() {
		proc.go#L3558: 		gcController.removeIdleMarkWorker()
		proc.go#L3948: 	if atomic.Load(&gcBlackenEnabled) == 0 || !gcController.needIdleMarkWorker() {
		proc.go#L3980: 	if gcBlackenEnabled == 0 || !gcController.addIdleMarkWorker() {
		proc.go#L3990: 		gcController.removeIdleMarkWorker()
		proc.go#L4181: 	gcController.releaseNextGCMarkWorker(pp)
		proc.go#L4508: 	gcController.addScannableStack(pp, -int64(gp.stack.hi-gp.stack.lo))
		proc.go#L4533: 		assistWorkPerByte := gcController.assistWorkPerByte.Load()
		proc.go#L4535: 		gcController.bgScanCredit.Add(scanCredit)
		proc.go#L5380: 	gcController.addScannableStack(pp, int64(newg.stack.hi-newg.stack.lo))
		proc.go#L6215: 			ok, _ := gcController.assignWaitingGCWorker(pp, now)
		proc.go#L6347: 	gcController.releaseNextGCMarkWorker(pp)
		stack.go#L913: 	gcController.addScannableStack(getg().m.p.ptr(), int64(newsize)-int64(old.hi-old.lo))
		symtab.go#L556: 			gcController.addGlobals(int64(scanDataSize + scanBSSSize))
		traceruntime.go#L569: 	heapGoal := gcController.heapGoal()
		traceruntime.go#L572: 	if heapGoal == ^uint64(0) || gcController.gcPercent.Load() < 0 {